﻿package net.ssta.core.web;

import java.io.IOException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;

import net.ssta.core.base.MultiPartRequest;
import net.ssta.core.db.PagingInfo;
import net.ssta.core.db.Record;

/**
 * 操作HttpServletRequest对象的工具类
 * @author qiuzhl
 *
 */
public class RequestKit 
{
	private HttpServletRequest m_request = null;
	public RequestKit(HttpServletRequest request)
	{
		m_request = request;
	}
	
	/**
	 * 从Request对象中取得请求的参数值，如果paramName指定的参数值为NULL或者空字符串，则返回defaultValue
	 * @param paramName
	 * @param defaultValue
	 * @return
	 */
	public String getParameter(String paramName,String defaultValue)
	{
		String ret = m_request.getParameter(paramName);
		return ( ret == null ||"".equals(ret) ) ? defaultValue : ret;
	}
	
	public String[] getParameterValues(String paramName)
	{
		return m_request.getParameterValues(paramName);
	}
	
	/**
	 * 从Request对象中取得属性值，如果attrName指定的属性值为NULL，则返回defaultValue
	 * @param paramName
	 * @param defaultValue
	 * @return
	 */
	public Object getAttribute(String attrName,Object defaultValue)
	{
		Object ret = m_request.getAttribute(attrName);
		return ( ret == null ) ? defaultValue : ret;
	}
	
	/**此方法的方法名少了一个字面b，以后使用setAttribute代替
	 * @deprecated
	 * @param attrName
	 * @param value
	 */
	public void setAttriute(String attrName,Object value)
	{
		m_request.setAttribute(attrName,value);
	}
	
	public void setAttribute(String attrName,Object value)
	{
		m_request.setAttribute(attrName,value);
	}
	
	/**
	 * 根据Request对象的请求参数值，生成Record对象，不忽略空白的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sPrefix 指定要获取的参数名称的前缀，只有以sPrefix开头的参数才被设置到Record对象中，字段名的前缀部分会被去掉
	 * @return
	 */
	public Record getRecordWithPrefix(String sPrefix)
	{
		return getRecordWithPrefix(sPrefix, false, false);
	}
	
	/**
	 * 从Request对象中取得请求的参数，生成Record对象，可以指定是否忽略空白值的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sPrefix 指定要获取的参数名称的前缀，只有以sPrefix开头的参数才被设置到Record对象中，字段名的前缀部分会被去掉
	 * @param bIgnoredNullOrEmptyValue  是否忽略空白值的参数
	 * @return
	 */
	public Record getRecordWithPrefix(String sPrefix, boolean bIgnoredNullOrEmptyValue)
	{
		return getRecordWithPrefix(sPrefix, bIgnoredNullOrEmptyValue, false);
	}
	
	/**
	 * 从Request对象中取得请求的参数，生成Record对象，如果有一个参数对应多个值，则此值是String[]
	 * @param sPrefix 指定要获取的参数名称的前缀，只有以sPrefix开头的参数才被设置到Record对象中，字段名的前缀部分会被去掉
	 * @param bIgnoredNullOrEmptyValue  指定是否忽略空白值的参数
	 * @param hasMultiValue             指定是否有一个参数对应多个值的情况
	 * @return
	 */
	public Record getRecordWithPrefix(String sPrefix, boolean bIgnoredNullOrEmptyValue, boolean hasMultiValue)
	{
		
		Enumeration<String> paramEnum = m_request.getParameterNames();
		int iPrefixLength = sPrefix == null ? 0 : sPrefix.length();
		Record record = new Record();
		while(paramEnum.hasMoreElements())
		{
		    String key = (String)paramEnum.nextElement();
			if(sPrefix != null && !key.startsWith(sPrefix)) continue;
		    if(hasMultiValue)
		    {
			    String values[] = m_request.getParameterValues(key);
			    if(bIgnoredNullOrEmptyValue && (values == null || values.length == 0)) continue;
			    record.addData(key.substring(iPrefixLength).toUpperCase(), values.length == 1 ? values[0] : values);
		    }
		    else
		    {
			    String value = m_request.getParameter(key);
			    if(bIgnoredNullOrEmptyValue && (value == null || "".equals(value))) continue;			
			    record.addData(key.substring(iPrefixLength).toUpperCase(), value);
		    }
		}
		return record;
	}
	
	/**
	 * 根据Request对象的请求参数值，生成Record对象，不忽略空白的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sRegion 指定匹配要获取的参数名称的正则表达式，只有sRegion匹配的参数才被设置到Record对象中
	 * @return
	 */
	public Record getRecordWithRegion(String sRegion)
	{
		Pattern p = null;
		if(sRegion != null && !"".equals(sRegion))
		{
			p = Pattern.compile(sRegion);
		}

		Enumeration<String> paramEnum = m_request.getParameterNames();
		Record record = new Record();
		while(paramEnum.hasMoreElements())
		{
		    String key = (String)paramEnum.nextElement();
		    if(p != null && !p.matcher(key).lookingAt()) continue;
		    String value = m_request.getParameter(key);
		    record.addData(key.toUpperCase(), value);
		}
		return record;
	}

	
	/**
	 * 从Request对象中取得请求的参数，以Map的形式返回，Map的value值是String，不忽略空白值的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sPrefix 指定要获取的参数名称的前缀，只有以sPrefix开头的参数才被设置到Map对象中，字段名的前缀部分会被去掉
	 * @return
	 */
	public Map<String,Object> getParamValuesWithPrefix(String sPrefix)
	{
		return getParamValuesWithPrefix( sPrefix, false, false);
	}
	
	/**
	 * 从Request对象中取得请求的参数，以Map的形式返回，Map的value值是String，不忽略空白值的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sRegion 指定匹配要获取的参数名称的正则表达式，只有sRegion匹配的参数才被设置到Map对象中
	 * @return
	 */
	public Map<String, String> getParamValuesWithRegion(String sRegion)
	{
		return getParamValuesWithRegion( sRegion, false, false);
	}
	
	/**
	 * 从Request对象中取得请求的参数，以Map的形式返回，Map的value值是String，可以指定是否忽略空白值的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sPrefix 指定要获取的参数名称的前缀，只有以sPrefix开头的参数才被设置到Map对象中，字段名的前缀部分会被去掉
	 * @param bIgnoredNullOrEmptyValue  是否忽略空白值的参数
	 * @return
	 */
	public Map<String, String> getParamValuesWithPrefix( String sPrefix, boolean bIgnoredNullOrEmptyValue)
	{
		return getParamValuesWithPrefix( sPrefix, bIgnoredNullOrEmptyValue, false);
	}
	
	/**
	 * 从Request对象中取得请求的参数，以Map的形式返回，Map的value值是String，可以指定是否忽略空白值的参数，如果有一个参数对应多个值的情况，则只取一个值
	 * @param sRegion 指定匹配要获取的参数名称的正则表达式，只有sRegion匹配的参数才被设置到Map对象中
	 * @param bIgnoredNullOrEmptyValue  是否忽略空白值的参数
	 * @return
	 */
	public Map<String, String> getParamValuesWithRegion(String sRegion, boolean bIgnoredNullOrEmptyValue)
	{
		return getParamValuesWithRegion( sRegion, bIgnoredNullOrEmptyValue, false);
	}
	
	/**
	 * 从Request对象中取得请求的参数，以Map的形式返回，如果每个参数只对应一个值，则Map的value值是String；如果有一个参数对应多个值，则Map的value值是String[]
	 * @param sPrefix 指定要获取的参数名称的前缀，只有以sPrefix开头的参数才被设置到Map对象中，字段名的前缀部分会被去掉
	 * @param bIgnoredNullOrEmptyValue  指定是否忽略空白值的参数
	 * @param hasMultiValue             指定是否有一个参数对应多个值的情况
	 * @return
	 */
	public Map getParamValuesWithPrefix(String sPrefix, boolean bIgnoredNullOrEmptyValue, boolean hasMultiValue)
	{
		Enumeration paramEnum = m_request.getParameterNames();
		Map<String,Object> params = new HashMap<String,Object>();
		int iPrefixLength = sPrefix == null ? 0 : sPrefix.length();
		while(paramEnum.hasMoreElements())
		{
		    String key = (String)paramEnum.nextElement();
		    if(sPrefix != null && !key.startsWith(sPrefix)) continue;
		    if(hasMultiValue)
		    {
			    String values[] = m_request.getParameterValues(key);
			    if(bIgnoredNullOrEmptyValue && values.length == 0) continue;
			    params.put(key.substring(iPrefixLength), values);
		    }
		    else
		    {
			    String value = m_request.getParameter(key);
			    if(bIgnoredNullOrEmptyValue && (value == null || "".equals(value))) continue;
			    params.put(key.substring(iPrefixLength), value);
		    }
		}
		return params;
	}
	
	/**
	 * 从Request对象中取得请求的参数，以Map的形式返回，如果每个参数只对应一个值，则Map的value值是String；如果有一个参数对应多个值，则Map的value值是String[]
	 * @param sRegion 指定匹配要获取的参数名称的正则表达式，只有sRegion匹配的参数才被设置到Map对象中
	 * @param bIgnoredNullOrEmptyValue  指定是否忽略空白值的参数
	 * @param hasMultiValue             指定是否有一个参数对应多个值的情况
	 * @return
	 */
	public Map getParamValuesWithRegion(String sRegion, boolean bIgnoredNullOrEmptyValue, boolean hasMultiValue)
	{
		Pattern p = null;
		if(sRegion != null && !"".equals(sRegion))
		{
			p = Pattern.compile(sRegion);
		}

		Enumeration paramEnum = m_request.getParameterNames();
		Map params = new HashMap();
		while(paramEnum.hasMoreElements())
		{
		    String key = (String)paramEnum.nextElement();
		    if(p != null && !p.matcher(key).lookingAt()) continue;
		    if(hasMultiValue)
		    {
			    String values[] = m_request.getParameterValues(key);
			    if(bIgnoredNullOrEmptyValue && values.length == 0) continue;
			    params.put(key, values);
		    }
		    else
		    {
			    String value = m_request.getParameter(key);
			    if(bIgnoredNullOrEmptyValue && (value == null || "".equals(value))) continue;
			    params.put(key, value);
		    }
		}
		return params;
	}
	
	/**
	 * 获取分页对象，即PagingInfo实例
	 * @param iPageSize 每页的记录数
	 * @param sRegion   过滤参数的正则表达式，只有该表达式匹配的参数才会在下次翻页时被提交到服务器
	 * @return
	 */
	public PagingInfo getPagingInfo(int iPageSize, String sRegion)
	{
		PagingInfo pagingInfo = new PagingInfo(m_request,iPageSize, sRegion);
		m_request.setAttribute("pagingInfo", pagingInfo);
		return pagingInfo;
	}
	
	/**
	 * 获取分页对象，即PagingInfo实例
	 * @param name 在attribute里面的name值
	 * @param iPageSize 每页的记录数
	 * @param sRegion   过滤参数的正则表达式，只有该表达式匹配的参数才会在下次翻页时被提交到服务器
	 * @return
	 */
	public PagingInfo getPagingInfo(String name, int iPageSize, String sRegion)
	{
		PagingInfo pagingInfo = new PagingInfo(m_request,iPageSize, sRegion);
		m_request.setAttribute(name, pagingInfo);
		return pagingInfo;
	}
	
	/**
	 * 根据当前的请求生成一个串，该串包含当前请求的URL和FORM参数，相当于一个QueryString
	 * @param region_filter  过滤要获取的参数名称的正则表达式，生成的查询串中只包含可以用filter_prefix匹配的参数
	 * @return  经过BASE编码的串
	 */
	/*public String getBackurl(String region_filter)
	{
	 	return BackURLEncoder.encode(m_request, region_filter);
	}*/
	
	


	

	
	/**
	 * 取得文件的数据（二进制）
	 */
	public byte[] getFileBinary(HttpServletRequest request, String paramName) {
		MultiPartRequest parser = (MultiPartRequest) request.getAttribute("MultiPartRequest_Parser");
		return parser.getFileBinary(paramName);
	}
	
	/**
	 * 取得文件的ContentType
	 */
	public String getFileContentType(HttpServletRequest request, String paramName) {
		MultiPartRequest parser = (MultiPartRequest) request.getAttribute("MultiPartRequest_Parser");
		return parser.getFileContentType(paramName);
	}
	
	/**
	 * 取得文件的文件名
	 */
	public String getFileName(HttpServletRequest request, String paramName) {
		MultiPartRequest parser = (MultiPartRequest) request.getAttribute("MultiPartRequest_Parser");
		return parser.getFileName(paramName);
	}
	
 
}
